#!/usr/bin/python3

def print_hello():
    print("hello")

print_hello();
print('--------------------------------------------------------------------------')

def max(a,b):
    if a>b:
        return a;
    else:
        return b;

print("max=",max(3,6))
print('--------------------------------------------------------------------------')

# 计算面积函数
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)
 
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
print('--------------------------------------------------------------------------')

ccc=[1,2,3]
ccc="Runoob"
# [1,2,3] 是 List 类型  "Runoob" 是 String 类型
# 而变量 ccc 是没有类型，仅仅是一个对象的引用


# 可更改(mutable)与不可更改(immutable)对象
# 在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

# 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
# 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

# python 函数的参数传递：
# 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
# 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
# python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

def change(a):     # id() 函数用于获取对象的内存地址
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)
print("a = ",a) # 内外不同
print('--------------------------------------------------------------------------')

# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])       # 内外同步修改
   print ("函数内取值: ", mylist)   # [10, 20, 30, [1, 2, 3, 4]]
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

print('--------------------------------------------------------------------------')

# 必需参数
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# printme()  # 调用 printme 函数，不加参数会报错

# 关键字参数
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return

#调用printme函数        关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
printme( str = "runoob")  # 相同函数找最后面的同名函数
print ("------------------------")

# 关键字参数
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")

#默认参数
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
printinfo( name="runoob" )
print ("------------------------")


# 不定长参数   加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
def printinfo( arg1, *vartuple ):
    "打印任何传入的参数"
    print ("输出: ")
    print (arg1)
    print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )
print ("------------------------")

def printinfo( arg1, *vartuple ):
    "打印任何传入的参数"
    print ("输出: ")
    print (arg1)
    for var in vartuple:  #空的就直接结束  有则一一打印
       print (var)
    return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

print ("------------------------")

# 不定长参数   加了两个星号 ** 的参数会以字典的形式导入
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

print ("------------------------")

# 声明函数时，参数中星号 * 可以单独出现  如果单独出现星号 * 后的参数必须用关键字传入
def f(a,b,*,c):
    return a+b+c

# f(1,2,3) # error
ret = f(1,2,c=3)
print(ret)

print ("------------------------")

# 不使用 def 语句这样标准的形式定义一个函数 
sum = lambda arg1, arg2: arg1 + arg2  # 前面未传入的参数 ：后为返回值

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

print ("------------------------")

# return
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return  total # 若为return 则返回none此无法与True或false比较
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)
if total == None:                   # 可以与none比较
    print("none")



